
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
// 
//   http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

/**
 * AUTO-GENERATED FILE. DO NOT MODIFY.
 */

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
// 
//   http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
import * as pathTool from 'zrender/lib/tool/path.js';
import * as matrix from 'zrender/lib/core/matrix.js';
import * as vector from 'zrender/lib/core/vector.js';
import Path from 'zrender/lib/graphic/Path.js';
import Transformable from 'zrender/lib/core/Transformable.js';
import ZRImage from 'zrender/lib/graphic/Image.js';
import Group from 'zrender/lib/graphic/Group.js';
import ZRText from 'zrender/lib/graphic/Text.js';
import Circle from 'zrender/lib/graphic/shape/Circle.js';
import Ellipse from 'zrender/lib/graphic/shape/Ellipse.js';
import Sector from 'zrender/lib/graphic/shape/Sector.js';
import Ring from 'zrender/lib/graphic/shape/Ring.js';
import Polygon from 'zrender/lib/graphic/shape/Polygon.js';
import Polyline from 'zrender/lib/graphic/shape/Polyline.js';
import Rect from 'zrender/lib/graphic/shape/Rect.js';
import Line from 'zrender/lib/graphic/shape/Line.js';
import BezierCurve from 'zrender/lib/graphic/shape/BezierCurve.js';
import Arc from 'zrender/lib/graphic/shape/Arc.js';
import CompoundPath from 'zrender/lib/graphic/CompoundPath.js';
import LinearGradient from 'zrender/lib/graphic/LinearGradient.js';
import RadialGradient from 'zrender/lib/graphic/RadialGradient.js';
import BoundingRect from 'zrender/lib/core/BoundingRect.js';
import OrientedBoundingRect from 'zrender/lib/core/OrientedBoundingRect.js';
import Point from 'zrender/lib/core/Point.js';
import IncrementalDisplayable from 'zrender/lib/graphic/IncrementalDisplayable.js';
import * as subPixelOptimizeUtil from 'zrender/lib/graphic/helper/subPixelOptimize.js';
import { extend, isArrayLike, map, defaults, isString, keys, each, hasOwn, isArray } from 'zrender/lib/core/util.js';
import { getECData } from './innerStore.js';
import { updateProps, initProps, removeElement, removeElementWithFadeOut, isElementRemoved } from '../animation/basicTransition.js';
/**
 * @deprecated export for compatitable reason
 */

export { updateProps, initProps, removeElement, removeElementWithFadeOut, isElementRemoved };
var mathMax = Math.max;
var mathMin = Math.min;
var _customShapeMap = {};
/**
 * Extend shape with parameters
 */

export function extendShape(opts) {
	return Path.extend(opts);
}
var extendPathFromString = pathTool.extendFromString;
/**
 * Extend path
 */

export function extendPath(pathData, opts) {
	return extendPathFromString(pathData, opts);
}
/**
 * Register a user defined shape.
 * The shape class can be fetched by `getShapeClass`
 * This method will overwrite the registered shapes, including
 * the registered built-in shapes, if using the same `name`.
 * The shape can be used in `custom series` and
 * `graphic component` by declaring `{type: name}`.
 *
 * @param name
 * @param ShapeClass Can be generated by `extendShape`.
 */

export function registerShape(name, ShapeClass) {
	_customShapeMap[name] = ShapeClass;
}
/**
 * Find shape class registered by `registerShape`. Usually used in
 * fetching user defined shape.
 *
 * [Caution]:
 * (1) This method **MUST NOT be used inside echarts !!!**, unless it is prepared
 * to use user registered shapes.
 * Because the built-in shape (see `getBuiltInShape`) will be registered by
 * `registerShape` by default. That enables users to get both built-in
 * shapes as well as the shapes belonging to themsleves. But users can overwrite
 * the built-in shapes by using names like 'circle', 'rect' via calling
 * `registerShape`. So the echarts inner featrues should not fetch shapes from here
 * in case that it is overwritten by users, except that some features, like
 * `custom series`, `graphic component`, do it deliberately.
 *
 * (2) In the features like `custom series`, `graphic component`, the user input
 * `{tpye: 'xxx'}` does not only specify shapes but also specify other graphic
 * elements like `'group'`, `'text'`, `'image'` or event `'path'`. Those names
 * are reserved names, that is, if some user registers a shape named `'image'`,
 * the shape will not be used. If we intending to add some more reserved names
 * in feature, that might bring break changes (disable some existing user shape
 * names). But that case probably rarely happens. So we don't make more mechanism
 * to resolve this issue here.
 *
 * @param name
 * @return The shape class. If not found, return nothing.
 */

export function getShapeClass(name) {
	if (_customShapeMap.hasOwnProperty(name)) {
		return _customShapeMap[name];
	}
}
/**
 * Create a path element from path data string
 * @param pathData
 * @param opts
 * @param rect
 * @param layout 'center' or 'cover' default to be cover
 */

export function makePath(pathData, opts, rect, layout) {
	var path = pathTool.createFromString(pathData, opts);

	if (rect) {
		if (layout === 'center') {
			rect = centerGraphic(rect, path.getBoundingRect());
		}

		resizePath(path, rect);
	}

	return path;
}
/**
 * Create a image element from image url
 * @param imageUrl image url
 * @param opts options
 * @param rect constrain rect
 * @param layout 'center' or 'cover'. Default to be 'cover'
 */

export function makeImage(imageUrl, rect, layout) {
	var zrImg = new ZRImage({
		style: {
			image: imageUrl,
			x: rect.x,
			y: rect.y,
			width: rect.width,
			height: rect.height
		},
		onload: function (img) {
			if (layout === 'center') {
				var boundingRect = {
					width: img.width,
					height: img.height
				};
				zrImg.setStyle(centerGraphic(rect, boundingRect));
			}
		}
	});
	return zrImg;
}
/**
 * Get position of centered element in bounding box.
 *
 * @param  rect         element local bounding box
 * @param  boundingRect constraint bounding box
 * @return element position containing x, y, width, and height
 */

function centerGraphic(rect, boundingRect) {
	// Set rect to center, keep width / height ratio.
	var aspect = boundingRect.width / boundingRect.height;
	var width = rect.height * aspect;
	var height;

	if (width <= rect.width) {
		height = rect.height;
	} else {
		width = rect.width;
		height = width / aspect;
	}

	var cx = rect.x + rect.width / 2;
	var cy = rect.y + rect.height / 2;
	return {
		x: cx - width / 2,
		y: cy - height / 2,
		width: width,
		height: height
	};
}

export var mergePath = pathTool.mergePath;
/**
 * Resize a path to fit the rect
 * @param path
 * @param rect
 */

export function resizePath(path, rect) {
	if (!path.applyTransform) {
		return;
	}

	var pathRect = path.getBoundingRect();
	var m = pathRect.calculateTransform(rect);
	path.applyTransform(m);
}
/**
 * Sub pixel optimize line for canvas
 */

export function subPixelOptimizeLine(shape, lineWidth) {
	subPixelOptimizeUtil.subPixelOptimizeLine(shape, shape, {
		lineWidth: lineWidth
	});
	return shape;
}
/**
 * Sub pixel optimize rect for canvas
 */

export function subPixelOptimizeRect(param) {
	subPixelOptimizeUtil.subPixelOptimizeRect(param.shape, param.shape, param.style);
	return param;
}
/**
 * Sub pixel optimize for canvas
 *
 * @param position Coordinate, such as x, y
 * @param lineWidth Should be nonnegative integer.
 * @param positiveOrNegative Default false (negative).
 * @return Optimized position.
 */

export var subPixelOptimize = subPixelOptimizeUtil.subPixelOptimize;
/**
 * Get transform matrix of target (param target),
 * in coordinate of its ancestor (param ancestor)
 *
 * @param target
 * @param [ancestor]
 */

export function getTransform(target, ancestor) {
	var mat = matrix.identity([]);

	while (target && target !== ancestor) {
		matrix.mul(mat, target.getLocalTransform(), mat);
		target = target.parent;
	}

	return mat;
}
/**
 * Apply transform to an vertex.
 * @param target [x, y]
 * @param transform Can be:
 *      + Transform matrix: like [1, 0, 0, 1, 0, 0]
 *      + {position, rotation, scale}, the same as `zrender/Transformable`.
 * @param invert Whether use invert matrix.
 * @return [x, y]
 */

export function applyTransform(target, transform, invert) {
	if (transform && !isArrayLike(transform)) {
		transform = Transformable.getLocalTransform(transform);
	}

	if (invert) {
		transform = matrix.invert([], transform);
	}

	return vector.applyTransform([], target, transform);
}
/**
 * @param direction 'left' 'right' 'top' 'bottom'
 * @param transform Transform matrix: like [1, 0, 0, 1, 0, 0]
 * @param invert Whether use invert matrix.
 * @return Transformed direction. 'left' 'right' 'top' 'bottom'
 */

export function transformDirection(direction, transform, invert) {
	// Pick a base, ensure that transform result will not be (0, 0).
	var hBase = transform[4] === 0 || transform[5] === 0 || transform[0] === 0 ? 1 : Math.abs(2 * transform[4] / transform[0]);
	var vBase = transform[4] === 0 || transform[5] === 0 || transform[2] === 0 ? 1 : Math.abs(2 * transform[4] / transform[2]);
	var vertex = [direction === 'left' ? -hBase : direction === 'right' ? hBase : 0, direction === 'top' ? -vBase : direction === 'bottom' ? vBase : 0];
	vertex = applyTransform(vertex, transform, invert);
	return Math.abs(vertex[0]) > Math.abs(vertex[1]) ? vertex[0] > 0 ? 'right' : 'left' : vertex[1] > 0 ? 'bottom' : 'top';
}

function isNotGroup(el) {
	return !el.isGroup;
}

function isPath(el) {
	return el.shape != null;
}
/**
 * Apply group transition animation from g1 to g2.
 * If no animatableModel, no animation.
 */

export function groupTransition(g1, g2, animatableModel) {
	if (!g1 || !g2) {
		return;
	}

	function getElMap(g) {
		var elMap = {};
		g.traverse(function (el) {
			if (isNotGroup(el) && el.anid) {
				elMap[el.anid] = el;
			}
		});
		return elMap;
	}

	function getAnimatableProps(el) {
		var obj = {
			x: el.x,
			y: el.y,
			rotation: el.rotation
		};

		if (isPath(el)) {
			obj.shape = extend({}, el.shape);
		}

		return obj;
	}

	var elMap1 = getElMap(g1);
	g2.traverse(function (el) {
		if (isNotGroup(el) && el.anid) {
			var oldEl = elMap1[el.anid];

			if (oldEl) {
				var newProp = getAnimatableProps(el);
				el.attr(getAnimatableProps(oldEl));
				updateProps(el, newProp, animatableModel, getECData(el).dataIndex);
			}
		}
	});
}
export function clipPointsByRect(points, rect) {
	// FIXME: This way might be incorrect when graphic clipped by a corner
	// and when element has a border.
	return map(points, function (point) {
		var x = point[0];
		x = mathMax(x, rect.x);
		x = mathMin(x, rect.x + rect.width);
		var y = point[1];
		y = mathMax(y, rect.y);
		y = mathMin(y, rect.y + rect.height);
		return [x, y];
	});
}
/**
 * Return a new clipped rect. If rect size are negative, return undefined.
 */

export function clipRectByRect(targetRect, rect) {
	var x = mathMax(targetRect.x, rect.x);
	var x2 = mathMin(targetRect.x + targetRect.width, rect.x + rect.width);
	var y = mathMax(targetRect.y, rect.y);
	var y2 = mathMin(targetRect.y + targetRect.height, rect.y + rect.height); // If the total rect is cliped, nothing, including the border,
	// should be painted. So return undefined.

	if (x2 >= x && y2 >= y) {
		return {
			x: x,
			y: y,
			width: x2 - x,
			height: y2 - y
		};
	}
}
export function createIcon(iconStr, // Support 'image://' or 'path://' or direct svg path.
	opt, rect) {
	var innerOpts = extend({
		rectHover: true
	}, opt);
	var style = innerOpts.style = {
		strokeNoScale: true
	};
	rect = rect || {
		x: -1,
		y: -1,
		width: 2,
		height: 2
	};

	if (iconStr) {
		return iconStr.indexOf('image://') === 0 ? (style.image = iconStr.slice(8), defaults(style, rect), new ZRImage(innerOpts)) : makePath(iconStr.replace('path://', ''), innerOpts, rect, 'center');
	}
}
/**
 * Return `true` if the given line (line `a`) and the given polygon
 * are intersect.
 * Note that we do not count colinear as intersect here because no
 * requirement for that. We could do that if required in future.
 */

export function linePolygonIntersect(a1x, a1y, a2x, a2y, points) {
	for (var i = 0, p2 = points[points.length - 1]; i < points.length; i++) {
		var p = points[i];

		if (lineLineIntersect(a1x, a1y, a2x, a2y, p[0], p[1], p2[0], p2[1])) {
			return true;
		}

		p2 = p;
	}
}
/**
 * Return `true` if the given two lines (line `a` and line `b`)
 * are intersect.
 * Note that we do not count colinear as intersect here because no
 * requirement for that. We could do that if required in future.
 */

export function lineLineIntersect(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
	// let `vec_m` to be `vec_a2 - vec_a1` and `vec_n` to be `vec_b2 - vec_b1`.
	var mx = a2x - a1x;
	var my = a2y - a1y;
	var nx = b2x - b1x;
	var ny = b2y - b1y; // `vec_m` and `vec_n` are parallel iff
	//     existing `k` such that `vec_m = k · vec_n`, equivalent to `vec_m X vec_n = 0`.

	var nmCrossProduct = crossProduct2d(nx, ny, mx, my);

	if (nearZero(nmCrossProduct)) {
		return false;
	} // `vec_m` and `vec_n` are intersect iff
	//     existing `p` and `q` in [0, 1] such that `vec_a1 + p * vec_m = vec_b1 + q * vec_n`,
	//     such that `q = ((vec_a1 - vec_b1) X vec_m) / (vec_n X vec_m)`
	//           and `p = ((vec_a1 - vec_b1) X vec_n) / (vec_n X vec_m)`.

	var b1a1x = a1x - b1x;
	var b1a1y = a1y - b1y;
	var q = crossProduct2d(b1a1x, b1a1y, mx, my) / nmCrossProduct;

	if (q < 0 || q > 1) {
		return false;
	}

	var p = crossProduct2d(b1a1x, b1a1y, nx, ny) / nmCrossProduct;

	if (p < 0 || p > 1) {
		return false;
	}

	return true;
}
/**
 * Cross product of 2-dimension vector.
 */

function crossProduct2d(x1, y1, x2, y2) {
	return x1 * y2 - x2 * y1;
}

function nearZero(val) {
	return val <= 1e-6 && val >= -1e-6;
}

export function setTooltipConfig(opt) {
	var itemTooltipOption = opt.itemTooltipOption;
	var componentModel = opt.componentModel;
	var itemName = opt.itemName;
	var itemTooltipOptionObj = isString(itemTooltipOption) ? {
		formatter: itemTooltipOption
	} : itemTooltipOption;
	var mainType = componentModel.mainType;
	var componentIndex = componentModel.componentIndex;
	var formatterParams = {
		componentType: mainType,
		name: itemName,
		$vars: ['name']
	};
	formatterParams[mainType + 'Index'] = componentIndex;
	var formatterParamsExtra = opt.formatterParamsExtra;

	if (formatterParamsExtra) {
		each(keys(formatterParamsExtra), function (key) {
			if (!hasOwn(formatterParams, key)) {
				formatterParams[key] = formatterParamsExtra[key];
				formatterParams.$vars.push(key);
			}
		});
	}

	var ecData = getECData(opt.el);
	ecData.componentMainType = mainType;
	ecData.componentIndex = componentIndex;
	ecData.tooltipConfig = {
		name: itemName,
		option: defaults({
			content: itemName,
			formatterParams: formatterParams
		}, itemTooltipOptionObj)
	};
}

function traverseElement(el, cb) {
	var stopped; // TODO
	// Polyfill for fixing zrender group traverse don't visit it's root issue.

	if (el.isGroup) {
		stopped = cb(el);
	}

	if (!stopped) {
		el.traverse(cb);
	}
}

export function traverseElements(els, cb) {
	if (els) {
		if (isArray(els)) {
			for (var i = 0; i < els.length; i++) {
				traverseElement(els[i], cb);
			}
		} else {
			traverseElement(els, cb);
		}
	}
} // Register built-in shapes. These shapes might be overwritten
// by users, although we do not recommend that.

registerShape('circle', Circle);
registerShape('ellipse', Ellipse);
registerShape('sector', Sector);
registerShape('ring', Ring);
registerShape('polygon', Polygon);
registerShape('polyline', Polyline);
registerShape('rect', Rect);
registerShape('line', Line);
registerShape('bezierCurve', BezierCurve);
registerShape('arc', Arc);
export { Group, ZRImage as Image, ZRText as Text, Circle, Ellipse, Sector, Ring, Polygon, Polyline, Rect, Line, BezierCurve, Arc, IncrementalDisplayable, CompoundPath, LinearGradient, RadialGradient, BoundingRect, OrientedBoundingRect, Point, Path };